package salt;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;

/**
 * 原理：
 * 所谓加盐就是将明文与动态生成16位的salt进行md5加密得到32位的加盐密文,存储时再将salt写进加盐密文得到48位带盐密文，
 * 之后每次进行校验时，就可将输入的明文与48位带盐密文中提取出的16位salt进行加密，再将结果与32位加盐密文进行比较
 *
 * 散列加密之32位哈希值的MD5算法，调用JDK里的API
 *ps：准确来说散列加密不是加密算法，因为它是不可逆的（只能加密，不能解密）
 */
public class Salt {

    private static char[] hex = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

    public static void main(String[] args) throws Exception {
        String input = "123456";
        System.out.println(String.format("MD5加密\n明文：%s\n无盐密文：%s",input,MD5WithoutSalt(input)));
        String withSaltCode = MD5WithSalt(input, 0);
        System.out.println("带盐密文：" + withSaltCode);
        System.out.println("校验结果："+verify(input,withSaltCode));
        /**
         * 第一次运行结果：
         *
         * MD5加密
         * 明文：123456
         * 无盐密文：E10ADC3949BA59ABBE56E057F20F883E
         * 加盐密文：78210E4986B9C5059AEF34C2F90BC5B3
         * 带盐密文：7D823100E4D98E6B59C850D594AECF324C62FA907BCB5BC3
         * 验证salt=D30DE58D4C26A7BC
         * 校验结果：true
         *
         * 第二运行结果：
         *
         * MD5加密
         * 明文：123456
         * 无盐密文：E10ADC3949BA59ABBE56E057F20F883E
         * 加盐密文：9E79AA7684D23FB6C0DBD2C425A12928
         * 带盐密文：98E7C9A4A7768F4D023CFB76CA0DCBDD2C442F5AF1259268
         * 验证salt=8C47F0C7ACD4FF56
         * 校验结果：true
         */
    }

    /**
     *@params: [inputStr] 输入明文
     *@Descrption: 不加盐MD5
     */
    public static String MD5WithoutSalt(String inputStr) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了
            return byte2HexStr(md.digest(inputStr.getBytes()));//哈希计算,转换输出
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }

    }

    /**
     *@params: [inputStr, type] inputStr是输入的明文;type是处理类型，0表示注册存hash值到库时，1表示登录验证时
     *@Descrption:  MD5加盐，盐的获取分两种情况;输入明文加盐；输出密文带盐(将salt存储到hash值中)
     */
    public static String MD5WithSalt(String inputStr, int type) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");//申明使用MD5算法,更改参数为"SHA"就是SHA算法了

            String salt = null;
            if (type == 0) {//注册存hash值到库时，new salt
                salt = salt();
            } else if (type == 1) {//登录验证时，使用从库中查找到的hash值提取出的salt
                String queriedHash=null;//从库中查找到的hash值
                salt=getSaltFromHash(queriedHash);
            }

            String inputWithSalt = inputStr + salt;//加盐，输入加盐
            String hashResult = byte2HexStr(md.digest(inputWithSalt.getBytes()));//哈希计算,转换输出
            System.out.println("加盐密文："+hashResult);

            /*将salt存储到hash值中，用于登陆验证密码时使用相同的盐*/
            char[] cs = new char[48];
            for (int i = 0; i < 48; i += 3) {
                cs[i] = hashResult.charAt(i / 3 * 2);
                cs[i + 1] = salt.charAt(i / 3);//输出带盐，存储盐到hash值中;每两个hash字符中间插入一个盐字符
                cs[i + 2] = hashResult.charAt(i / 3 * 2 + 1);
            }
            hashResult = new String(cs);
            return hashResult;
        } catch (Exception e) {
            e.printStackTrace();
            return e.toString();
        }
    }


    /**
     * @return: salt
     * @params:
     * @Descrption: 自定义简单生成盐，是一个随机生成的长度为16的字符串，每一个字符是随机的十六进制字符
     */
    public static String salt() {
        Random random = new Random();
        StringBuilder sb = new StringBuilder(16);
        for (int i = 0; i < sb.capacity(); i++) {
            sb.append(hex[random.nextInt(16)]);
        }
        return sb.toString();
    }

    /**
     * @return: 十六进制字符串
     * @params: [bytes]
     * @Descrption: 将字节数组转换成十六进制字符串
     */
    private static String byte2HexStr(byte[] bytes) {
        /**
         *@Author: DavidHuang
         *@Time: 19:41 2018/5/10
         *@return: java.lang.String
         *@params:  * @param bytes
         *@Descrption:
         */
        int len = bytes.length;
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < len; i++) {
            byte byte0 = bytes[i];
            result.append(hex[byte0 >>> 4 & 0xf]);
            result.append(hex[byte0 & 0xf]);
        }
        return result.toString();
    }


    /**
     *@return: 提取的salt
     *@params: [hash] 3i byte带盐的hash值,带盐方法与MD5WithSalt中相同
     *@Descrption:  从库中查找到的hash值提取出的salt
     */
    public static String getSaltFromHash(String hash){
        StringBuilder sb=new StringBuilder();
        char [] h=hash.toCharArray();
        for(int i=0;i<hash.length();i+=3){
            sb.append(h[i+1]);
        }
        return sb.toString();
    }

    /**
     * 校验密码是否正确
     */
    public static boolean verify(String rawPass, String encodePass) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            char[] cs = encodePass.toCharArray();
            char[] cs1 = new char[32];
            char[] cs2 = new char[16];
            for (int i = 0; i < 48; i += 3) {
                cs1[i / 3 * 2] = cs[i];
                cs1[i / 3 * 2 + 1] = cs[i + 2];
                cs2[i / 3] = cs[i + 1];
            }
            String salt = new String(cs2);
            System.out.println("验证salt=" + salt);
            return byte2HexStr(md.digest((rawPass+salt).getBytes())).equals(new String(cs1));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return false;
    }

}